"""
多态：
面向对象的核心特征，
允许不同类对同一消息做出不同的回应
就是在不同的对象上调用相同的方法名，
可能会产生不同的行为
灵活性和可扩展性

多态还有鸭子类型
普通的多态实现有继承的体现
而鸭子类型可以不实现继承
"""


# 定义一个父类 Animal
class Animal:
    def speak(self):
        pass


# 定义子类 Dog，继承自 Animal 并重写 speak 方法
class Dog(Animal):
    def speak(self):
        return "汪汪汪"


# 定义子类 Cat，继承自 Animal 并重写 speak 方法
class Cat(Animal):
    def speak(self):
        return "喵喵喵"


# 定义一个函数，接收一个 Animal 类型的对象并调用其 speak 方法
def animal_speak(animal):
    print(animal.speak())


# 创建 Dog 和 Cat 类的对象
dog = Dog()
cat = Cat()

# 调用 animal_speak 函数，传入不同的对象
animal_speak(dog)
animal_speak(cat)


# 定义一个类 Duck，具有 quack 方法
class Duck:
    def quack(self):
        print("嘎嘎嘎")


# 定义一个类 Person，具有 quack 方法
class Person:
    def quack(self):
        print("我模仿鸭子叫")


# 定义一个函数，接收一个具有 quack 方法的对象
def make_quack(obj):
    obj.quack()


# 创建 Duck 和 Person 类的对象
duck = Duck()
person = Person()

# 调用 make_quack 函数，传入不同的对象
make_quack(duck)
make_quack(person)


"""
继承：
面向对象的核心概念，
如果有多个类有相同相似的属性和方法的话，
可以把他们提取为共同的父类，
子类继承父类，
子类可以在父类上进行扩展
"""


# 定义父类 Animal
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name} 正在吃东西。")


# 定义子类 Dog，继承自 Animal
class Dog(Animal):
    def bark(self):
        print(f"{self.name} 正在汪汪叫。")


# 创建 Dog 类的对象
dog = Dog("旺财")
# 调用从父类继承的方法
dog.eat()
# 调用子类自己的方法
dog.bark()


class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        print("动物发出声音。")


class Cat(Animal):
    def make_sound(self):
        print(f"{self.name} 正在喵喵叫。")


cat = Cat("咪咪")
cat.make_sound()


class Flyable:
    def fly(self):
        print("正在飞行。")


class Swimmable:
    def swim(self):
        print("正在游泳。")


class Duck(Flyable, Swimmable):
    def quack(self):
        print("嘎嘎叫。")


duck = Duck()
duck.fly()
duck.swim()
duck.quack()


class Parent:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"你好，我是 {self.name}。")


class Child(Parent):
    def greet(self):
        super().greet()
        print("很高兴见到你。")


child = Child("小明")
child.greet()



"""
面向对象：
是一种解决问题的思想，
将现实世界与计算机编程联系起来解决问题，
就拿python来说，
就是将一些具体的事务，
如数据与操作数据的方法抽象为一个整体，
也就是类
将事务所具有的静态的属性、动态的行为抽象为类中所具有的属性和方法


面向对象又有三大特性：封装、继承、多态
"""

# 同样这也是封装的实现，将数据与行为捆绑，留出接口供后续使用
# 定义一个表示人的类
class Person:
    # 构造方法，用于初始化对象的属性
    def __init__(self, name, age):
        # 姓名属性
        self.name = name
        # 年龄属性
        self.age = age

    # 方法，用于描述人的行为
    def introduce(self):
        print(f"我叫 {self.name}，今年 {self.age} 岁。")


# 创建一个 Person 类的对象
p = Person("张三", 25)
# 调用对象的方法
p.introduce()
